home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / osrc.arc / SESSION.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-22  |  7.3 KB  |  380 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "socket.h"
  7. #include "ftpcli.h"
  8. #include "telnet.h"
  9. #include "icmp.h"
  10. #include "ax25tnc.h"
  11. #include "session.h"
  12. #include "cmdparse.h"
  13. #include "timer.h"
  14. #include "proc.h"
  15. #include "tty.h"
  16.  
  17. char *psocket(),*tcp_port();
  18. char *sockstate();
  19. void tel_upload();
  20.  
  21. struct session *Sessions;
  22. struct session *Current;
  23. int Mode = CMD_MODE;
  24.  
  25. char Notval[] = "Not a valid control block\n";
  26. char Badsess[] = "Invalid session\n";
  27. char *Sestypes[] = {
  28.     "",
  29.     "Telnet",
  30.     "FTP",
  31.     "AX25",
  32.     "Finger",
  33.     "Ping",
  34. };
  35.  
  36. /* Convert a character string containing a decimal session index number 
  37.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  38.  * If the index is out of range or unused, return NULLSESSION.
  39.  */
  40. struct session *
  41. sessptr(cp)
  42. char *cp;
  43. {
  44.     register struct session *sp;
  45.     unsigned int i;
  46.  
  47.     if(cp == NULLCHAR){
  48.         sp = Current;
  49.     } else {
  50.         i = (unsigned)atoi(cp);
  51.         if(i >= Nsessions)
  52.             sp = NULLSESSION;
  53.         else
  54.             sp = &Sessions[i];
  55.     }
  56.     if(sp == NULLSESSION || sp->type == FREE)
  57.         sp = NULLSESSION;
  58.  
  59.     return sp;
  60. }
  61.  
  62. /* Select and display sessions */
  63. int
  64. dosession(argc,argv)
  65. int argc;
  66. char *argv[];
  67. {
  68.     struct session *sp;
  69.     struct sockaddr fsocket;
  70.     int i,k,s;
  71.     int r,t;
  72.     char *cp;
  73.  
  74.     if(argc > 1){
  75.         if((sp = sessptr(argv[1])) != NULLSESSION){
  76.             go(0,NULL,sp);
  77.         } else
  78.             printf("Session %s not active\n",argv[1]);
  79.         return 0;
  80.     }
  81.     printf(" #  S#  Type     Rcv-Q Snd-Q State        Remote socket\n");
  82.     for(sp=Sessions; sp < &Sessions[Nsessions];sp++){
  83.         if(sp->type == FREE)
  84.             continue;
  85.  
  86.         i = SOCKSIZE;
  87.         s = sp->s;
  88.         k = getpeername(s,(char *)&fsocket,&i);
  89.         r = socklen(s,0);
  90.         t = socklen(s,1);
  91.         cp = sockstate(s);
  92.         printf("%c%-3u%-4d%-8s%6d%6d %-13s%s",
  93.          (Current == sp)? '*':' ',
  94.          (unsigned)(sp - Sessions),
  95.          s,
  96.          Sestypes[sp->type],
  97.          r,
  98.          t,
  99.          (cp != NULLCHAR) ? cp : "",
  100.          (sp->name != NULLCHAR) ? sp->name : "");
  101.         if(k == 0)
  102.             printf(" (%s)",psocket(&fsocket));
  103.  
  104.         if(sp->rfile != NULLCHAR || sp->ufile != NULLCHAR)
  105.             printf("\t");
  106.         if(sp->rfile != NULLCHAR)
  107.             printf("Record: %s ",sp->rfile);
  108.         if(sp->ufile != NULLCHAR)
  109.             printf("Upload: %s",sp->ufile);
  110.         printf("\n");
  111.         if(sp->type == FTP && (s = sp->cb.ftp->data) != -1){
  112.             /* Display data channel, if any */
  113.             i = SOCKSIZE;
  114.             k = getpeername(s,(char *)&fsocket,&i);
  115.             r = socklen(s,0);
  116.             t = socklen(s,1);
  117.             cp = sockstate(s);
  118.             printf("    %-4d%-8s%6d%6d %-13s%s",
  119.              s,
  120.              Sestypes[sp->type],
  121.              r,
  122.              t,
  123.              (cp != NULLCHAR) ? cp : "",
  124.              (sp->name != NULLCHAR) ? sp->name : "");
  125.             if(k == 0)
  126.                 printf(" (%s)",psocket(&fsocket));
  127.             printf("\n");
  128.         }
  129.     }
  130.     return 0;
  131. }
  132. /* Resume current session, and wait for it */
  133. int
  134. go(argc,argv,sp)
  135. int argc;
  136. char *argv[];
  137. struct session *sp;
  138. {
  139.     if(sp == NULLSESSION || sp->type == FREE)
  140.         return 0;
  141.     Current = sp;
  142.     ttysetmode(sp->ttymode);
  143.     Mode = CONV_MODE;
  144.     psignal(sp,0);
  145.     switch(sp->type){
  146.     case TELNET:
  147.         pwait(sp->cb.telnet->output);
  148.         break;
  149.     case FTP:
  150.         pwait(sp->cb.ftp->output);
  151.         break;
  152.     case AX25TNC:
  153.         pwait(sp->cb.ax25->output);
  154.         break;
  155.     case PING:
  156.         pwait(sp->cb.ping->proc);
  157.         break;
  158.     }
  159.     return 0;
  160. }
  161. int
  162. doclose(argc,argv,sp)
  163. int argc;
  164. char *argv[];
  165. struct session *sp;
  166. {
  167.     if(argc > 1)
  168.         sp = sessptr(argv[1]);
  169.  
  170.     if(sp == NULLSESSION){
  171.         printf(Badsess);
  172.         return -1;
  173.     }
  174.     shutdown(sp->s,1);
  175.     return 0;
  176. }
  177. int
  178. doreset(argc,argv,sp)
  179. int argc;
  180. char *argv[];
  181. register struct session *sp;
  182. {
  183.     if(argc > 1)
  184.         sp = sessptr(argv[1]);
  185.  
  186.     if(sp == NULLSESSION){
  187.         printf(Badsess);
  188.         return -1;
  189.     }
  190.     /* Unwedge anyone waiting for a domain resolution, etc */
  191.     switch(sp->type){
  192.     case FTP:
  193.         alert(sp->cb.ftp->output,-1);
  194.         break;
  195.     case TELNET:
  196.         alert(sp->cb.telnet->output,-1);
  197.         break;
  198.     case FINGER:
  199.         alert(sp->cb.finger,-1);
  200.         break;
  201.     case AX25TNC:
  202.         break;
  203.     case PING:
  204.         alert(sp->cb.ping->proc,-1);
  205.         break;
  206.     }
  207.     shutdown(sp->s,2);
  208.     if(sp->type == FTP)
  209.         shutdown(sp->cb.ftp->data,2);
  210.     return 0;
  211. }
  212. int
  213. dokick(argc,argv,sp)
  214. int argc;
  215. char *argv[];
  216. struct session *sp;
  217. {
  218.     if(argc > 1)
  219.         sp = sessptr(argv[1]);
  220.  
  221.     if(sp == NULLSESSION){
  222.         printf(Badsess);
  223.         return -1;
  224.     }
  225.     sockkick(sp->s);
  226.     if(sp->type == FTP)
  227.         sockkick(sp->cb.ftp->data);
  228.     return 0;
  229. }
  230.  
  231. struct session *
  232. newsession(name,type)
  233. char *name;
  234. int type;
  235. {
  236.     register struct session *sp;
  237.  
  238.     for(sp=Sessions;sp < &Sessions[Nsessions];sp++){
  239.         if(sp->type == FREE){
  240.             sp->type = type;
  241.             sp->s = -1;
  242.             if(name != NULLCHAR)
  243.                 sp->name = strdup(name);
  244.  
  245.             return sp;
  246.         }
  247.     }
  248.     return NULLSESSION;
  249. }
  250. void
  251. freesession(sp)
  252. struct session *sp;
  253. {
  254.     if(sp == NULLSESSION)
  255.         return;
  256.     if(sp->s != -1)
  257.         close_s(sp->s);
  258.     free_q(&sp->input);
  259.     if(sp->record != NULLFILE){
  260.         fclose(sp->record);
  261.         sp->record = NULLFILE;
  262.     }
  263.     free(sp->rfile);
  264.     sp->rfile = NULLCHAR;
  265.     if(sp->upload != NULLFILE){
  266.         fclose(sp->upload);
  267.         sp->upload = NULLFILE;
  268.     }
  269.     free(sp->ufile);
  270.     sp->ufile = NULLCHAR;
  271.     free(sp->name);
  272.     sp->name = NULLCHAR;
  273.     sp->type = FREE;
  274.     if(Current == sp){
  275.         Current = NULLSESSION;
  276.         Mode = CMD_MODE;
  277.     }
  278. }
  279. /* Control session recording */
  280. int
  281. dorecord(argc,argv,sp)
  282. int argc;
  283. char *argv[];
  284. struct session *sp;
  285. {
  286.     
  287.     if(sp == NULLSESSION){
  288.         printf("No current session\n");
  289.         return 1;
  290.     }
  291.     if(argc > 1){
  292.         if(sp->rfile != NULLCHAR){
  293.             fclose(sp->record);
  294.             free(sp->rfile);
  295.             sp->record = NULLFILE;
  296.             sp->rfile = NULLCHAR;
  297.         }
  298.         /* Open new record file, unless file name is "off", which means
  299.          * disable recording
  300.          */
  301.         if(strcmp(argv[1],"off") != 0){
  302.             if((sp->record = fopen(argv[1],APPEND_TEXT)) == NULLFILE)
  303.                 printf("Can't open %s: %s\n",argv[1],sys_errlist[errno]);
  304.             else
  305.                 sp->rfile = strdup(argv[1]);
  306.         }
  307.     }
  308.     if(sp->rfile != NULLCHAR)
  309.         printf("Recording into %s\n",sp->rfile);
  310.     else
  311.         printf("Recording off\n");
  312.     return 0;
  313. }
  314. /* Control file transmission */
  315. int
  316. doupload(argc,argv,sp)
  317. int argc;
  318. char *argv[];
  319. struct session *sp;
  320. {
  321.     struct telnet *tn;
  322.     struct ax25tnc *axp;
  323.  
  324.     if(sp == NULLSESSION){
  325.         printf("No current session\n");
  326.         return 1;
  327.     }
  328.     if(argc < 2){
  329.         if(sp->ufile != NULLCHAR)
  330.             printf("Uploading %s\n",sp->ufile);
  331.         else
  332.             printf("Uploading off\n");
  333.         return 0;
  334.     }
  335.     switch(sp->type){
  336.     case TELNET:
  337.         tn = sp->cb.telnet;
  338.         break;
  339.     case AX25TNC:
  340.         axp = sp->cb.ax25;
  341.         break;
  342.     default:
  343.         printf("Uploading not supported\n");
  344.         return 1;
  345.     }
  346.     if(strcmp(argv[1],"stop") == 0 && sp->upload != NULLFILE){
  347.         /* Abort upload */
  348.         fclose(sp->upload);
  349.         sp->upload = NULLFILE;
  350.         free(sp->ufile);
  351.         sp->ufile = NULLCHAR;
  352.         if(tn != NULLTN){
  353.             killproc(tn->upload);
  354.             tn->upload = NULLPROC;
  355.         } else if(axp != NULLTNC){
  356.             killproc(axp->upload);
  357.             axp->upload = NULLPROC;
  358.         }
  359.         return 0;
  360.     }
  361.     /* Open upload file */
  362.     if((sp->upload = fopen(argv[1],READ_TEXT)) == NULLFILE){
  363.         printf("Can't read %s: %s\n",argv[1],sys_errlist[errno]);
  364.         return 1;
  365.     }
  366.     sp->ufile = strdup(argv[1]);
  367.     /* All set, invoke the upload process */
  368.     switch(sp->type){
  369. #ifdef    AX25
  370.     case AX25TNC:
  371.         axp->upload = newproc("upload",1024,ax_upload,0,sp,NULL);
  372.         break;
  373. #endif
  374.     case TELNET:
  375.         tn->upload = newproc("upload",1024,tel_upload,0,sp,NULL);
  376.         break;
  377.     }
  378.     return 0;
  379. }
  380.